{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Toy Problem - Lie group approach\n",
    "\n",
    "![Toy Problem](../toy_problem.png)\n",
    "\n",
    "Another way we could approach the same state estimation task is to instead use Lie group theory, which is becoming increasingly common practice in state estimation. Lie group theory can be very abstract, and the main references that navlie refer to are the following:\n",
    "\n",
    "1. [A micro Lie theory for state estimation in robotics](https://arxiv.org/abs/1812.01537)\n",
    "2. [T.Barfoot, State Estimation for Robotics](http://asrl.utias.utoronto.ca/~tdb/bib/barfoot_ser17.pdf)\n",
    "\n",
    "\n",
    "## Define the State\n",
    "Instead of representing the state using a vector, we will represent the state using an element of the *special Euclidean group* $SE(2)$, sometimes called *pose transformation matrices*. Elements of this group are 3x3 matrices of the form \n",
    "\n",
    "$$ \n",
    "\\mathbf{T} = \\begin{bmatrix} \\mathbf{C}_{ab}(\\theta) & \\mathbf{r}_a \\\\ \\mathbf{0} & 1 \\end{bmatrix} \\in SE(2)\n",
    "$$\n",
    "\n",
    "where $\\mathbf{r}_a = [x,y]^T$ again denotes the position of the robot and $\\mathbf{C}_{ab}(\\theta) \\in SO(2)$ is a rotation matrix (sometimes called a direction cosine matrix) with the form \n",
    "\n",
    "$$ \n",
    "\\mathbf{C}_{ab}(\\theta) = \\begin{bmatrix} \\cos \\theta & - \\sin \\theta \\\\ \\sin \\theta & \\cos \\theta \\end{bmatrix}.\n",
    "$$\n",
    "\n",
    "The rotation matrix transforms vectors resolved in one frame to another frame, i.e. $\\mathbf{r}_a = \\mathbf{C}_{ab} \\mathbf{r}_b$. Unlike vectors, elements of $SO(2)$ or $SE(2)$ cannot be added together to produce another valid element of $SE(2)$, but they can be multiplied together with the result still having the same form.\n",
    "\n",
    "$$\n",
    "\\mathbf{T}_1 \\mathbf{T}_2 \\in SE(2)\n",
    "$$\n",
    "\n",
    " To proceed further with our mathematical setup, we need to define a few very common operators seen in Lie group theory. The first two are the \"wedge\" $(\\cdot)^\\wedge$ and \"vee\" $(\\cdot)^\\vee$ operators, which for this specific group has the form\n",
    "\n",
    "$$ \n",
    "\\begin{bmatrix} \\theta \\\\ x \\\\ y \\end{bmatrix}^\\wedge = \\begin{bmatrix} 0 & -\\theta & x \\\\ \\theta & 0 & y \\\\ 0 & 0 & 0 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "and the $(\\cdot)^\\vee$ operator simply does the exact inverse of $(\\cdot)^\\wedge$. We can implement them as follows.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "import numpy as np\n",
    "\n",
    "# Helper functions for SE(2)\n",
    "def wedge_se2(x):\n",
    "    return np.array([[   0, -x[0], x[1]],\n",
    "                     [x[0],     0, x[2]], \n",
    "                     [   0,     0,    0]])\n",
    "\n",
    "def vee_se2(X):\n",
    "    return np.array([X[1, 0], X[0, 2], X[1, 2]])\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Two other fundamental relationships appearing in Lie group theory are the exponential (denoted $\\exp$) and logarithmic (denoted $\\log$) maps. While these have a deeper definition, for our case it suffices to think of them  as simply the [matrix exponential](https://en.wikipedia.org/wiki/Matrix_exponential) and [matrix logarithm](https://en.wikipedia.org/wiki/Logarithm_of_a_matrix). Using the wedge and vee operators for $SE(2)$ defined above, we can convert a 3x1 vector to an $SE(2)$ element and back as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An element of SE2:\n",
      "[[ 0.99500417 -0.09983342  0.18467933]\n",
      " [ 0.09983342  0.99500417  0.30949192]\n",
      " [ 0.          0.          1.        ]]\n",
      "\n",
      "The original vector 'representing' it:\n",
      "[0.1 0.2 0.3]\n"
     ]
    }
   ],
   "source": [
    "from scipy.linalg import expm, logm\n",
    "\n",
    "T = expm(wedge_se2(np.array([0.1, 0.2, 0.3])))\n",
    "print(\"An element of SE2:\")\n",
    "print(T)\n",
    "\n",
    "x = vee_se2(logm(T))\n",
    "print(\"\\nThe original vector 'representing' it:\")\n",
    "print(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have the tools we need to abstract-ify our problem a little bit. As commonly seen in the literature, we can define the so-called \"oplus\" and \"ominus\" operators as follows (sometimes called \"boxplus\" $\\boxplus$ and \"boxminus\" $\\boxminus$):\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\mathbf{T}_2 &= \\mathbf{T}_1 \\oplus \\boldsymbol{\\xi} := \\mathbf{T}_1 \\exp(\\boldsymbol{\\xi}^\\wedge)  \\\\\n",
    "\\boldsymbol{\\varepsilon} &= \\mathbf{T}_2 \\ominus \\mathbf{T}_1 := \\log(\\mathbf{T}_2^{-1} \\mathbf{T}_1)^\\vee\n",
    "\\end{aligned}\n",
    "$$ \n",
    "\n",
    "Here, both $\\boldsymbol{\\varepsilon}, \\boldsymbol{\\xi} \\in \\mathbb{R}^3$ are 3x1 vectors. The $\\oplus: SE(2) \\times \\mathbb{R}^3 \\to SE(2)$ operator \"adds\" a vector to an $SE(2)$ element to produce another $SE(2)$ element, and the $\\ominus:SE(2) \\times SE(2) \\to \\mathbb{R}^3$ operator \"subtracts\" two $SE(2)$ elements to produce a vector that represents the \"difference\" between them. \n",
    "\n",
    "\n",
    "With this context, lets implement an $SE(2)$ state inside navlie's framework. To define a custom state, you must subclass the `nav.State` abstract class and you *must* implement the `plus`, `minus`, and `copy` methods. These methods play exactly the role of $\\oplus$ and $\\ominus$ described above, while the `copy` method is used to create a deep copy of that state object. In addition, state objects must hold an integer property named `dof` that specifies the *degrees of freedom* associated with that state. For $SE(2)$, this is 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SE2State(stamp=0.0, dof=3, state_id=None)\n",
      "    [[1. 0. 0.]\n",
      "     [0. 1. 0.]\n",
      "     [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "import navlie as nav\n",
    "\n",
    "class SE2State(nav.State):\n",
    "    def __init__(self, value :np.ndarray, stamp: float):\n",
    "        super().__init__(value=value, dof=3, stamp=stamp)\n",
    "\n",
    "    def plus(self, dx: np.ndarray):\n",
    "        new_value = self.value @ expm(wedge_se2(dx))\n",
    "        return SE2State(new_value, self.stamp)\n",
    "\n",
    "    def minus(self, other: \"SE2State\"):\n",
    "        other_inv = np.linalg.inv(other.value)\n",
    "        return vee_se2(logm(other_inv @ self.value))\n",
    "    \n",
    "    def copy(self):\n",
    "        return SE2State(self.value.copy(), self.stamp)\n",
    "\n",
    "x = SE2State(np.eye(3), 0.0)\n",
    "print(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the Process Model\n",
    "\n",
    "Now, we must adapt the process model to work with our new `SE2State`. It is well known that the rotational kinematics can be written directly in terms of rotation matrices using \n",
    "\n",
    "$$ \n",
    "\\dot{\\mathbf{C}}_{ab} = \\mathbf{C}_{ab}\\begin{bmatrix}0 & -\\omega \\\\ \\omega & 0 \\end{bmatrix} \n",
    "$$\n",
    "\n",
    "and that the translational kinematics can be written in vector form using \n",
    "\n",
    "$$ \n",
    "\\dot{\\mathbf{r}}_a = \\mathbf{C}_{ab} \\begin{bmatrix} v \\\\ 0 \\end{bmatrix} .\n",
    "$$\n",
    "\n",
    "By stacking these into matrices it follows that \n",
    "$$ \n",
    "\\dot{\\mathbf{T}} = \\mathbf{T} \\boldsymbol{\\varpi}^\\wedge\n",
    "$$\n",
    "\n",
    "where $\\boldsymbol{\\varpi} = [\\omega, v, 0]^T$. This equation is now a linear, matrix-valued ODE, and can be integrated exactly over a short duration $\\Delta t = t_{k+1} - t_k$ using the matrix exponential. This gives us the following discrete-time process model:\n",
    "\n",
    "$$\n",
    "\\mathbf{T}_{k+1} = \\mathbf{T}_k \\exp(\\boldsymbol{\\varpi}_k^\\wedge \\Delta t)\n",
    "$$\n",
    "\n",
    "which we can implement as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WheeledRobotSE2(nav.ProcessModel):\n",
    "    def __init__(self, input_covariance_matrix):\n",
    "        self.Q = input_covariance_matrix\n",
    "\n",
    "    def evaluate(self, x:SE2State, u:nav.lib.VectorInput, dt:float):\n",
    "        vel = np.array([u.value[0], u.value[1], 0])\n",
    "        x_next = x.copy()\n",
    "        x_next.value = x.value @ expm(wedge_se2(vel * dt))\n",
    "        return x_next\n",
    "    \n",
    "    def input_covariance(self, x:SE2State, u:nav.lib.VectorInput, dt:float):\n",
    "        return self.Q\n",
    "\n",
    "Q = np.eye(2) * 0.1**2\n",
    "process_model = WheeledRobotSE2(Q)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the Measurement Model\n",
    "\n",
    "Finally, our measurement model remains largely unchanged. We just need to extract the position from an `SE2State` object now, as done below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RangeToLandmarkSE2(nav.MeasurementModel):\n",
    "    def __init__(\n",
    "        self,\n",
    "        landmark_position: np.ndarray,\n",
    "        measurement_covariance: float,\n",
    "    ):\n",
    "        self.landmark_position = landmark_position\n",
    "        self.R = measurement_covariance\n",
    "\n",
    "    def evaluate(self, x: SE2State):\n",
    "        pos = x.value[0:2, 2]\n",
    "        return np.linalg.norm(pos - self.landmark_position)\n",
    "\n",
    "    def covariance(self, x: SE2State):\n",
    "        return self.R\n",
    "    \n",
    "\n",
    "landmarks = np.array([[1, 1], [1, 2], [2, 2], [2, 1]])\n",
    "meas_models = [RangeToLandmarkSE2(landmark,  0.1**2) for landmark in landmarks]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run the Filter!\n",
    "\n",
    "And that's it! All remaining snippets are now _literally_ copy-pasted from our previous approach with zero modifications. Using the abstraction framework in navlie, we can easily switch between different state representations and process/measurement models without having to change any of data generation or filtering code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SE2State(stamp=0.02, dof=3, state_id=None)\n",
      "    [[ 9.99950000e-01 -9.99983333e-03  5.99990000e-03]\n",
      "     [ 9.99983333e-03  9.99950000e-01  2.99997500e-05]\n",
      "     [ 0.00000000e+00  0.00000000e+00  1.00000000e+00]]\n",
      "VectorInput(stamp=0.04, state_id=None)\n",
      "    [0.52438924 0.40056502]\n",
      "Measurement(stamp=0.0, state_id=None) of PoseRangeToLandMark\n",
      "    2.299276237837416\n"
     ]
    }
   ],
   "source": [
    "dg = nav.DataGenerator(\n",
    "    process_model=process_model,                  # process model to use\n",
    "    input_func=lambda t, x: np.array([0.5, 0.3]), # a callable that specifies the input values over time\n",
    "    input_covariance= Q,                          # numpy array or callable that specifies the input covariance over time\n",
    "    input_freq=50,                                # the frequency (Hz) at which the input is sampled (and the process model integrated)\n",
    "    meas_model_list=meas_models,                  # a list of measurement models to use\n",
    "    meas_freq_list=[10, 10, 10, 10]               # corresponding measurement frequencies (Hz)\n",
    ")\n",
    "\n",
    "state_data, input_data, meas_data = dg.generate(x, start=0, stop=30, noise=True)\n",
    "\n",
    "print(state_data[1])\n",
    "print(input_data[2])\n",
    "print(meas_data[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# First, define the filter\n",
    "kalman_filter = nav.ExtendedKalmanFilter(process_model)\n",
    "P0 = np.diag([0.1**2, 1**2, 1**2])  # Initial covariance\n",
    "x = nav.StateWithCovariance(x, P0)  # Estimate and covariance in one container\n",
    "\n",
    "meas_idx = 0\n",
    "y = meas_data[meas_idx]\n",
    "estimates = []\n",
    "for k in range(len(input_data) - 1):\n",
    "    u = input_data[k]\n",
    "\n",
    "    # Fuse any measurements that have occurred.\n",
    "    while y.stamp < input_data[k + 1].stamp and meas_idx < len(meas_data):\n",
    "        x = kalman_filter.correct(x, y, u)\n",
    "\n",
    "        # Load the next measurement\n",
    "        meas_idx += 1\n",
    "        if meas_idx < len(meas_data):\n",
    "            y = meas_data[meas_idx]\n",
    "\n",
    "    # Predict until the next input is available\n",
    "    dt = input_data[k + 1].stamp - x.state.stamp\n",
    "    x = kalman_filter.predict(x, u, dt)\n",
    "\n",
    "    estimates.append(x.copy())\n",
    "\n",
    "\n",
    "results = nav.GaussianResultList.from_estimates(estimates, state_data)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "fig, axs = nav.plot_error(results)\n",
    "axs[0].set_title(\"Estimation Errors\")\n",
    "axs[0].set_ylabel(\"theta (rad)\")\n",
    "axs[1].set_ylabel(\"x (m)\")\n",
    "axs[2].set_ylabel(\"y (m)\")\n",
    "axs[2].set_xlabel(\"Time (s)\")\n",
    "\n",
    "fig, ax = nav.plot_nees(results)\n",
    "ax.set_title(\"NEES\")\n",
    "ax.set_xlabel(\"Time (s)\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Lie group states \n",
    "While we implemented our own `SE2State` from scratch here for pedagogical purposes, navlie comes with many built-in Lie group states that you can use out of the box. Some of the built-in Lie group states include:\n",
    "\n",
    "- `nav.lib.SO2State`: representing 2D rotations using, beloning to the group $SO(2)$\n",
    "- `nav.lib.SO3State`: representing 3D rotations using, beloning to the group $SO(3)$\n",
    "- `nav.lib.SE2State`: representing 2D poses using, beloning to the group $SE(2)$\n",
    "- `nav.lib.SE3State`: representing 3D poses using, beloning to the group $SE(3)$\n",
    "- `nav.lib.SE23State`: representing \"extended\" poses that also contain velocity information, belonging to the group $SE_2(3)$\n",
    "- `nav.lib.SL3State`: representing 3D homographies, belonging to the group $SL(3)$\n",
    "\n",
    "Each of these classes stores the value as a square numpy array in the `x.value` property. Moreover, closed-form formulas for the exponential and logarithmic maps have been implemented for each of these states, which is faster than using `scipy.linalg.expm` and `scipy.linalg.logm`. These underlying operations have even been implemented in C++ for maximum speed. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
